home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part2 / 18011 < prev    next >
Encoding:
Text File  |  1996-08-05  |  3.4 KB  |  122 lines
  1. Path: news.th-darmstadt.de!news
  2. From: Enno Sandner <enno@intellektik.informatik.th-darmstadt.de>
  3. Newsgroups: comp.lang.c++
  4. Subject: Re: Here is my idea of callback code. However there are glitches can it be done better.
  5. Date: Thu, 18 Apr 1996 15:56:34 +0200
  6. Organization: Fachbereich Informatik, TH Darmstadt
  7. Message-ID: <31764A12.1CFBAE39@intellektik.informatik.th-darmstadt.de>
  8. References: <Pine.SUN.3.91N2x.960418124921.4515B-100000@mumrik.nada.kth.se>
  9. NNTP-Posting-Host: kitz.intellektik.informatik.th-darmstadt.de
  10. Mime-Version: 1.0
  11. Content-Type: text/plain; charset=iso-8859-1
  12. Content-Transfer-Encoding: 8bit
  13. X-Mailer: Mozilla 2.01 (X11; I; SunOS 4.1.3 sun4m)
  14.  
  15. Fredrik ╓hrstr÷m wrote:
  16. > 
  17. > How do people write callbacks? The following code captures what I want
  18. > of callbacks.
  19. > * Callbacks call class functions.
  20. > * The calling object does not need to know what object, what function,
  21. >   what callback it is calling. It knows that it calls a TutCallback f.ex.
  22. >   but if the user wants to subclass the TutCallback to insert more
  23. >   information at callback time thats completely ok.
  24. > * It is easy to create new callbacks. (Before I hade to create two classes
  25. >   for each new callback.)
  26. > However there are some negative things.
  27. > * It is a pointer to pointer to function thingi.
  28. > * The compiler warns >>Contravariance violation<<
  29. >   Because I cast b = void (Test::*)(TutCallback*)
  30. >                   to void (Test::*)(Callback*)
  31. >   And I do not know how to stop this from happening.
  32. > 
  33. >   Is there anyone out there that has a better way of calling callbacks?
  34. >   Or if somebody knows how to fix this I would be very happy!
  35. > 
  36. > Here's the code. (Just the essential stuff, no memchecking and so on.)
  37. > 
  38. > #include <iostream.h>
  39. > 
  40. > struct Caller;
  41. > template<class T> struct Call;
  42. > struct Callback;
  43. > 
  44. > struct Caller
  45. > {
  46. >   virtual void call (Callback *cb) { }
  47. > };
  48. > 
  49. > template<class T>
  50. > struct Call : public Caller
  51. > {
  52. >   typedef void (T::*FuncPtr)(Callback *);
  53. > 
  54. >   Call (T *o, FuncPtr f) : object_(o), function_(FuncPtr(f)) { }
  55. > 
  56. >   void call (Callback *cb) { (object_->*function_) (cb); }
  57. > 
  58. >   T *object_;
  59. >   FuncPtr function_;
  60. > };
  61. > 
  62. > struct Callback
  63. > {
  64. >   Callback (Caller *caller) : caller_ (caller) { }
  65. >   virtual void invoke () { caller_->call (this); }
  66. > 
  67. >   Caller *caller_;
  68. > };
  69. > 
  70. > // This is an easy way to create new Callbacks I think!
  71. > 
  72. > struct TutCallback : public Callback
  73. > {
  74. >   TutCallback (Caller *c, int u) : Callback (c), tut (u) { }
  75. > 
  76. >   int tut;
  77. > };
  78. > 
  79. > struct Test
  80. > {
  81. >   TutCallback *cb;
  82. > 
  83. >   Test ()
  84. >   {
  85. >     cb = new TutCallback (new Call<Test>(this,b), 5);
  86. >     cb->invoke ();
  87. >   }
  88. > 
  89. >   void b (TutCallback *cb)
  90. >   {
  91. >     cerr << "Tut! " << cb->tut << endl;
  92. >   }
  93. > };
  94. > 
  95. > int main ()
  96. > {
  97. >   Test test;
  98. > }
  99.  
  100. Basically your idea is ok (check out the 'Command Pattern' in the Design
  101. Patterns book for a more general approach).
  102. To remove the problems you can make 'Caller' a generic class that takes
  103. the type of the argument of the 'call' function:
  104.  
  105.        template<class Arg> class Caller {
  106.           public:
  107.           virtual ~Caller() {}    
  108.           virtual void call(Arg a)=0;
  109.        };
  110.  
  111. The resulting subclass 'Call' becomes generic with two arguments.
  112.      
  113.        template<class T,class Arg> class Call : public Caller<Arg> { ... };
  114.  
  115. This and the appropriate modifications allows you to write:
  116.  
  117.     cb = new TutCallback (new Call<Test,TutCallback*>(this,b), 5);
  118.  
  119. in Test's constructor without any problems.
  120.  
  121.     Enno
  122.